<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content=
    "application/xhtml+xml; charset=iso-8859-1" />
    <title>
      Rustc-1.42.0
    </title>
    <link rel="stylesheet" type="text/css" href="../stylesheets/lfs.css" />
    <meta name="generator" content="DocBook XSL Stylesheets V1.78.1" />
    <link rel="stylesheet" href="../stylesheets/lfs-print.css" type=
    "text/css" media="print" />
  </head>
  <body class="blfs" id="blfs-2020-04-02">
    <div class="navheader">
      <h4>
        Beyond Linux<sup>�</sup> From Scratch <span class="phrase">(System
        V</span> Edition) - Version 2020-04-02
      </h4>
      <h3>
        Chapter&nbsp;13.&nbsp;Programming
      </h3>
      <ul>
        <li class="prev">
          <a accesskey="p" href="ruby.html" title="Ruby-2.7.1">Prev</a>
          <p>
            Ruby-2.7.1
          </p>
        </li>
        <li class="next">
          <a accesskey="n" href="scons.html" title="SCons-3.1.2">Next</a>
          <p>
            SCons-3.1.2
          </p>
        </li>
        <li class="up">
          <a accesskey="u" href="prog.html" title=
          "Chapter&nbsp;13.&nbsp;Programming">Up</a>
        </li>
        <li class="home">
          <a accesskey="h" href="../index.html" title=
          "Beyond Linux� From Scratch     (System V Edition) - Version 2020-04-02">
          Home</a>
        </li>
      </ul>
    </div>
    <div class="sect1" lang="en" xml:lang="en">
      <h1 class="sect1">
        <a id="rust" name="rust"></a>Rustc-1.42.0
      </h1>
      <div class="package" lang="en" xml:lang="en">
        <h2 class="sect2">
          Introduction to Rust
        </h2>
        <p>
          The <span class="application">Rust</span> programming language is
          designed to be a safe, concurrent, practical language.
        </p>
        <p>
          This package is updated on a six-weekly release cycle. Because it
          is such a large and slow package to build, is at the moment only
          required by a few packages in this book, and particularly because
          newer versions tend to break older mozilla packages, the BLFS
          editors take the view that it should only be updated when that is
          necessary (either to fix problems, or to allow a new version of a
          package to build).
        </p>
        <p>
          As with many other programming languages, rustc (the rust compiler)
          needs a binary from which to bootstrap. It will download a stage0
          binary and many cargo crates (these are actually .tar.gz source
          archives) at the start of the build, so you cannot compile it
          without an internet connection.
        </p>
        <p>
          These crates will then remain in various forms (cache, directories
          of extracted source), in <code class="filename">~/.cargo</code> for
          ever more. It is common for large <span class=
          "application">rust</span> packages to use multiple versions of some
          crates. If you purge the files before updating this package, very
          few crates will need to be updated by the packages in this book
          which use it (and they will be downloaded as required). But if you
          retain an older version as a fallback option and then use it (when
          <span class="emphasis"><em>not</em></span> building in <code class=
          "filename">/usr</code>), it is likely that it will then have to
          re-download some crates. For a full download (i.e. starting with an
          empty or missing <code class="filename">~/.cargo</code>)
          downloading the external cargo files for this version only takes a
          minute or so on a fast network.
        </p>
        <div class="admon note">
          <img alt="[Note]" src="../images/note.png" />
          <h3>
            Note
          </h3>
          <p>
            Although BLFS usually installs in <code class=
            "filename">/usr</code>, when you later upgrade to a newer version
            of <span class="application">rust</span> the old libraries in
            <code class="filename">/usr/lib/rustlib</code> will remain, with
            various hashes in their names, but will not be usable and will
            waste space. The editors recommend placing the files in the
            <code class="filename">/opt</code> directory. In particular, if
            you have reason to rebuild with a modified configuration (e.g.
            using the shipped LLVM after building with shared LLVM, or for
            the reverse situation) it is possible for the install to leave a
            broken <span class="command"><strong>cargo</strong></span>
            program. In such a situation, either remove the existing
            installation first, or use a different prefix such as
            /opt/rustc-1.42.0-build2.
          </p>
          <p>
            If you prefer, you can of course change the prefix to
            <code class="filename">/usr</code> and omit the <span class=
            "command"><strong>ldconfig</strong></span> and the actions to add
            rustc to the PATH.
          </p>
        </div>
        <p>
          The current <span class="application">rustbuild</span> build-system
          will use all available processors, although it does not scale well
          and often falls back to just using one core while waiting for a
          library to compile.
        </p>
        <p>
          At the moment <span class="application">Rust</span> does not
          provide any guarantees of a stable ABI.
        </p>
        <div class="admon note">
          <img alt="[Note]" src="../images/note.png" />
          <h3>
            Note
          </h3>
          <p>
            Rustc defaults to building for ALL supported architectures, using
            a shipped copy of LLVM. In BLFS the build is only for the X86
            architecture. Rustc still claims to require Python 2, but that is
            only really necessary when building some other architectures with
            the shipped LLVM. If you intend to develop rust crates, this
            build may not be good enough for your purposes.
          </p>
          <p>
            The build times of this version when repeated on the same machine
            are often reasonably consistent, but as with all compilations
            using <span class="command"><strong>rustc</strong></span> there
            can be some very slow outliers.
          </p>
          <p>
            Unusually, a DESTDIR-style method is being used to install this
            package. This is because running the install as root not only
            downloads all of the cargo files again (to <code class=
            "filename">/root/.cargo</code>), it then spends a very long time
            recompiling. Using this method saves a lot of time, at the cost
            of extra disk space.
          </p>
        </div>
        <p>
          This package is known to build and work properly using an LFS-9.1
          platform.
        </p>
        <h3>
          Package Information
        </h3>
        <div class="itemizedlist">
          <ul class="compact">
            <li class="listitem">
              <p>
                Download (HTTP): <a class="ulink" href=
                "https://static.rust-lang.org/dist/rustc-1.42.0-src.tar.gz">https://static.rust-lang.org/dist/rustc-1.42.0-src.tar.gz</a>
              </p>
            </li>
            <li class="listitem">
              <p>
                Download MD5 sum: ff5731326898a7010403e1b148375de4
              </p>
            </li>
            <li class="listitem">
              <p>
                Download size: 130 MB
              </p>
            </li>
            <li class="listitem">
              <p>
                Estimated disk space required: 5.7 GB (250 MB installed)
                including 344 MB of ~/.cargo files for the user building
                this. Add 2.5 GB if running the tests
              </p>
            </li>
            <li class="listitem">
              <p>
                Estimated build time: 33 SBU (add 17 SBU for tests, both on a
                4-core machine)
              </p>
            </li>
          </ul>
        </div>
        <h3>
          Rust Dependencies
        </h3>
        <h4>
          Required
        </h4>
        <p class="required">
          <a class="xref" href="../basicnet/curl.html" title=
          "cURL-7.69.1">cURL-7.69.1</a>, <a class="xref" href="cmake.html"
          title="CMake-3.17.0">CMake-3.17.0</a>, and <a class="xref" href=
          "libssh2.html" title="libssh2-1.9.0">libssh2-1.9.0</a>
        </p>
        <h4>
          Recommended
        </h4>
        <p class="recommended">
          <span class="package">clang</span> from <a class="xref" href=
          "llvm.html" title="LLVM-10.0.0">LLVM-10.0.0</a> (built with
          -DLLVM_LINK_LLVM_DYLIB=ON so that rust can link to system LLVM
          instead of building its shipped version) If using an older version,
          see the config.toml file below re using the shipped llvm, because
          of rust issue 69225.
        </p>
        <h4>
          Optional
        </h4>
        <p class="optional">
          <a class="xref" href="gdb.html" title="GDB-9.1">GDB-9.1</a> (used
          by the testsuite if it is present) and <a class="xref" href=
          "python2.html" title="Python-2.7.17">Python-2.7.17</a> (used by the
          testsuite)
        </p>
        <p class="usernotes">
          User Notes: <a class="ulink" href=
          "http://wiki.linuxfromscratch.org/blfs/wiki/rust">http://wiki.linuxfromscratch.org/blfs/wiki/rust</a>
        </p>
      </div>
      <div class="installation" lang="en" xml:lang="en">
        <h2 class="sect2">
          Installation of Rust
        </h2>
        <p>
          To install into the <code class="filename">/opt</code> directory,
          remove the symlink and create a new directory (i.e. with a
          different name if trying a modified build). As the <code class=
          "systemitem">root</code> user:
        </p>
        <pre class="root">
<kbd class="command">mkdir /opt/rustc-1.42.0             &amp;&amp;
ln -svfin rustc-1.42.0 /opt/rustc</kbd>
</pre>
        <div class="admon note">
          <img alt="[Note]" src="../images/note.png" />
          <h3>
            Note
          </h3>
          <p>
            If multiple versions of <span class="application">Rust</span> are
            installed in <code class="filename">/opt</code>, changing to
            another version only requires changing the <code class=
            "filename">/opt/rustc</code> symbolic link and then running
            <span class="command"><strong>ldconfig</strong></span>.
          </p>
        </div>
        <p>
          Create a suitable <code class="filename">config.toml</code> file
          which will configure the build.
        </p>
        <pre class="userinput">
<kbd class="command">cat &lt;&lt; EOF &gt; config.toml
<code class="literal"># see config.toml.example for more possible options
# See the 8.4 book for an example using shipped LLVM
# e.g. if not installing clang, or using a version before 10.0
[llvm]
# by default, rust will build for a myriad of architectures
targets = "X86"

[build]
# omit docs to save time and space (default is to build them)
docs = false

# install cargo as well as rust
extended = true

[install]
prefix = "/opt/rustc-1.42.0"
docdir = "share/doc/rustc-1.42.0"

[rust]
channel = "stable"
rpath = false

# BLFS does not install the FileCheck executable from llvm,
# so disable codegen tests
codegen-tests = false

[target.x86_64-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"

[target.i686-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"

</code>
EOF</kbd>
</pre>
        <p>
          Compile <span class="application">Rust</span> by running the
          following commands:
        </p>
        <pre class="userinput">
<kbd class=
"command">export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" &amp;&amp;
python3 ./x.py build --exclude src/tools/miri</kbd>
</pre>
        <div class="admon note">
          <img alt="[Note]" src="../images/note.png" />
          <h3>
            Note
          </h3>
          <p>
            The testsuite will generate some messages in the <span class=
            "phrase">system log</span> for traps on invalid opcodes, and for
            segmentation faults. In themselves these are nothing to worry
            about, just a way for the test to be terminated.
          </p>
        </div>
        <p>
          To run the tests issue <span class="command"><strong>python3 ./x.py
          test --verbose --no-fail-fast | tee rustc-testlog</strong></span>:
          as with the build, that will use all available CPUs.
        </p>
        <p>
          The instructions above do not build ARM compilers, so the testsuite
          <span class="emphasis"><em>will</em></span> fail and the tests will
          be reported to end in error, with a backtrace of the last failing
          test. On a good run, 3 tests which need Thumb (ARM) compilers will
          fail, all in <code class="filename">ui/issues</code> for issues
          37131, 49851 and 50993. A fourth test, <code class=
          "filename">run-make-fulldeps/sysroot-crates-are-unstable</code>
          fails, presumably because we are using only stable features. As
          with all large testsuites, other tests might fail on some machines
          - if the number of failures is in the single digits, check the log
          for 'FAILED' and review lines above that, particularly the
          'stderr:' lines. Any mention of SIGSEGV or signal 11 in a failing
          test is a cause for concern.
        </p>
        <p>
          If you get any <span class="emphasis"><em>other</em></span> failing
          test which reports an issue number then you should search for that
          issue. For example, when rustc &gt;= 1.41.1 is built with a version
          of sysllvm before 10.0 the test for issue 69225 fails <a class=
          "ulink" href=
          "https://github.com/rust-lang/rust/issues/69225">https://github.com/rust-lang/rust/issues/69225</a>
          and that should be regarded as a critical failure (they released
          1.41.1 because of it). Most other failures will not be critical.
        </p>
        <p>
          Therefore, you should determine the number of failures. The total
          number of tests varies depending on which dependencies are present,
          e.g. more will be run if <span class=
          "command"><strong>gdb</strong></span> is available. If you wish,
          the total number which were considered can be found if you run:
        </p>
        <pre class="userinput">
<kbd class=
"command">egrep 'running [[:digit:]]+ test' rustc-testlog | awk '{ sum += $2 } END { print sum }'</kbd>
</pre>
        <p>
          More importantly, the total of tests which failed can be found by
          running:
        </p>
        <pre class="userinput">
<kbd class=
"command">grep '^test result:' rustc-testlog | awk  '{ sum += $6 } END { print sum }'</kbd>
</pre>
        <p>
          And similarly if you care about how many tests passed use $4, for
          those which were ignored (i.e. skipped) use $8 (and $10 for
          'measured', $12 for 'filtered out' but both are probably zero).
        </p>
        <p>
          Still as your normal user, do a DESTDIR install:
        </p>
        <pre class="userinput">
<kbd class="command">export LIBSSH2_SYS_USE_PKG_CONFIG=1 &amp;&amp;
DESTDIR=${PWD}/install python3 ./x.py install &amp;&amp;
unset LIBSSH2_SYS_USE_PKG_CONFIG</kbd>
</pre>
        <p>
          Now, as the <code class="systemitem">root</code> user install the
          files from the DESTDIR:
        </p>
        <pre class="root">
<kbd class="command">chown -R root:root install &amp;&amp;
cp -a install/* /</kbd>
</pre>
      </div>
      <div class="commands" lang="en" xml:lang="en">
        <h2 class="sect2">
          Command Explanations
        </h2>
        <p>
          <span class="command"><strong>ln -svfn rustc-1.42.0
          /opt/rustc</strong></span>: if this is not the first use of the
          <code class="filename">/opt/rustc</code> symlink, overwrite it by
          forcing, and use the '-n' flag to avoid getting confusing results
          from e.g. <span class="command"><strong>ls -l</strong></span>.
        </p>
        <p>
          <span class="command"><strong>targets = "X86"</strong></span>: this
          avoids building all the available linux cross-compilers (Aarch64,
          MIPS, PowerPC, SystemZ, etc). Unfortunately, rust insists on
          installing source files for these below <code class=
          "filename">/opt/rustc/lib/src</code>.
        </p>
        <p>
          <span class="command"><strong>extended = true</strong></span>: this
          installs Cargo alongside Rust.
        </p>
        <p>
          <span class="command"><strong>channel = "stable"</strong></span>:
          this ensures only stable features can be used, the default in
          <code class="filename">config.toml</code> is to use development
          features, which is not appropriate for a released version.
        </p>
        <p>
          <span class="command"><strong>rpath = false</strong></span>: by
          default, <span class="command"><strong>rust</strong></span> can be
          run from where it was built, without being installed. That adds
          DT_RPATH entries to all of the ELF files, which produces very messy
          output from <span class="command"><strong>ldd</strong></span>,
          showing the libraries in the place they were built, even if they
          have been deleted from there after the install.
        </p>
        <p>
          <span class=
          "command"><strong>[target.x86_64-unknown-linux-gnu]</strong></span>:
          the syntax of <code class="filename">config.toml</code> requires an
          <code class="literal">llvm-config</code> entry for each target for
          which system-llvm is to be used. Change the target to <code class=
          "literal">[target.i686-unknown-linux-gnu]</code> if you are
          building on 32-bit x86. This whole section may be omitted if you
          wish to build against the shipped llvm, or do not have clang, but
          the resulting build will be larger and take longer.
        </p>
        <p>
          <span class="command"><strong>export RUSTFLAGS="$RUSTFLAGS -C
          link-args=-lffi"</strong></span>: This adds a link to libffi to any
          RUSTFLAGS you may already be passing to the build. On some systems,
          linking fails to include libffi unless this is used. The reason why
          this is needed is not clear.
        </p>
        <p>
          <span class="command"><strong>--exclude
          src/tools/miri</strong></span>: For a long time, the miri crate (an
          interpreter for the Midlevel Intermediate Representation) has
          failed to build on releases. It is optional, but the failure
          messages can persuade people that the whole build failed. However,
          although it is not built in the main compile, with rustc-1.35.0 it
          now gets compiled during the install, but it is broken in this
          version.
        </p>
        <p>
          <span class="command"><strong>--verbose</strong></span>: this
          switch can sometimes provide more information about a test which
          fails.
        </p>
        <p>
          <span class="command"><strong>--no-fail-fast</strong></span>: this
          switch ensures that the testsuite will not stop at the first error.
        </p>
        <p>
          <span class="command"><strong>export
          LIBSSH2_SYS_USE_PKG_CONFIG=1</strong></span>: On some systems,
          cairo fails to link during the install because it cannot find
          libssh2. This seems to fix it, but again the reason why the problem
          occurs is not understood.
        </p>
        <p>
          <span class="command"><strong>DESTDIR=${PWD}/install python3 ./x.py
          install</strong></span>: This effects a DESTDIR-style install in
          the source tree,creating an <code class="filename">install</code>
          directory. Note that DESTDIR installs need an absolute path,
          passing 'install' will not work.
        </p>
        <p>
          <span class="command"><strong>chown -R root:root
          install</strong></span>: the DESTDIR install was run by a regular
          user, who owns the files. For security, change their owner before
          doing a simple copy to install them.
        </p>
      </div>
      <div class="configuration" lang="en" xml:lang="en">
        <h2 class="sect2">
          Configuring Rust
        </h2>
        <div class="sect3" lang="en" xml:lang="en">
          <h3 class="sect3">
            <a id="rustc-config" name="rustc-config"></a>
          </h3>
          <h4 class="title">
            <a id="rustc-config" name="rustc-config"></a>Configuration
            Information
          </h4>
          <p>
            If you installed <span class="application">rustc</span> in
            <code class="filename">/opt</code>, you need to update the
            following configuration files so that <span class=
            "application">rustc</span> is correctly found by other packages
            and system processes.
          </p>
          <p>
            As the <code class="systemitem">root</code> user, update the
            <code class="filename">/etc/ld.so.conf</code> file and the
            dynamic linker's run-time cache file:
          </p>
          <pre class="root">
<kbd class="command">cat &gt;&gt; /etc/ld.so.conf &lt;&lt; EOF
<code class="literal"># Begin rustc addition

/opt/rustc/lib

# End rustc addition</code>
EOF

ldconfig</kbd>
</pre>
          <p>
            As the <code class="systemitem">root</code> user, create the
            <code class="filename">/etc/profile.d/rustc.sh</code> file:
          </p>
          <pre class="root">
<kbd class="command">cat &gt; /etc/profile.d/rustc.sh &lt;&lt; "EOF"
<code class="literal"># Begin /etc/profile.d/rustc.sh

pathprepend /opt/rustc/bin           PATH

# End /etc/profile.d/rustc.sh</code>
EOF</kbd>
</pre>
          <p>
            Immediately after installation, update the current PATH for your
            current shell as a normal user:
          </p>
          <pre class="userinput">
<kbd class="command">source /etc/profile.d/rustc.sh</kbd>
</pre>
        </div>
      </div>
      <div class="content" lang="en" xml:lang="en">
        <h2 class="sect2">
          Contents
        </h2>
        <div class="segmentedlist">
          <div class="seglistitem">
            <div class="seg">
              <strong class="segtitle">Installed Programs:</strong>
              <span class="segbody">cargo-clippy, cargo-fmt, cargo-miri,
              cargo, clippy-driver, miri, rls, rust-gdb, rust-gdbgui,
              rust-lldb, rustc, rustdoc, rustfmt.</span>
            </div>
            <div class="seg">
              <strong class="segtitle">Installed Libraries:</strong>
              <span class="segbody">Many lib*&lt;16-byte-hash&gt;.so
              libraries.</span>
            </div>
            <div class="seg">
              <strong class="segtitle">Installed Directories:</strong>
              <span class="segbody">~/.cargo, /opt/rustc/lib/rustlib,
              /opt/rustc/share/doc/rustc-1.42.0, and
              /opt/rustc/share/zsh/site-functions</span>
            </div>
          </div>
        </div>
        <div class="variablelist">
          <h3>
            Short Descriptions
          </h3>
          <table border="0" class="variablelist">
            <colgroup>
              <col align="left" valign="top" />
              <col />
            </colgroup>
            <tbody>
              <tr>
                <td>
                  <p>
                    <a id="cargo-clippy" name="cargo-clippy"></a><span class=
                    "term"><span class=
                    "command"><strong>cargo-clippy</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    provides lint checks for a cargo package.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="cargo-fmt" name="cargo-fmt"></a><span class=
                    "term"><span class=
                    "command"><strong>cargo-fmt</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    formats all bin and lib files of the current crate using
                    rustfmt.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="cargo-miri" name="cargo-miri"></a><span class=
                    "term"><span class=
                    "command"><strong>cargo-miri</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is for use by Miri to interpret bin crates and tests
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="cargo" name="cargo"></a><span class=
                    "term"><span class=
                    "command"><strong>cargo</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is the Package Manager for Rust.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="clippy-driver" name=
                    "clippy-driver"></a><span class="term"><span class=
                    "command"><strong>clippy-driver</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    provides lint checks for Rust.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="miri" name="miri"></a><span class=
                    "term"><span class=
                    "command"><strong>miri</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is an interpreter for Rust's mid-level intermediate
                    representation (MIR). It is broken in this version.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rls" name="rls"></a><span class=
                    "term"><span class="command"><strong>rls</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is the Rust Language Server. This can run in the
                    background to provide IDEs, editors, and other tools with
                    information about Rust programs.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rust-gdb" name="rust-gdb"></a><span class=
                    "term"><span class=
                    "command"><strong>rust-gdb</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is a wrapper script for gdb, pulling in Python
                    pretty-printing modules installed in <code class=
                    "filename">/usr/lib/rustlib/etc</code>.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rust-gdbgui" name="rust-gdbgui"></a><span class=
                    "term"><span class=
                    "command"><strong>rust-gdbgui</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is a wrapper script for a graphical front end to gdb that
                    runs in a browser.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rust-lldb" name="rust-lldb"></a><span class=
                    "term"><span class=
                    "command"><strong>rust-lldb</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is a wrapper script for LLDB (the LLVM debugger) pulling
                    in the Python pretty-printing modules.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rustc" name="rustc"></a><span class=
                    "term"><span class=
                    "command"><strong>rustc</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    is the rust compiler.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rustdoc" name="rustdoc"></a><span class=
                    "term"><span class=
                    "command"><strong>rustdoc</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    generates documentation from rust source code.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="rustfmt" name="rustfmt"></a><span class=
                    "term"><span class=
                    "command"><strong>rustfmt</strong></span></span>
                  </p>
                </td>
                <td>
                  <p>
                    formats rust code.
                  </p>
                </td>
              </tr>
              <tr>
                <td>
                  <p>
                    <a id="libstd" name="libstd"></a><span class=
                    "term"><code class=
                    "filename">libstd-&lt;16-byte-hash&gt;.so</code></span>
                  </p>
                </td>
                <td>
                  <p>
                    is the Rust Standard Library, the foundation of portable
                    Rust software.
                  </p>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </div>
      <p class="updated">
        Last updated on 2020-04-01 15:15:24 -0500
      </p>
    </div>
    <div class="navfooter">
      <ul>
        <li class="prev">
          <a accesskey="p" href="ruby.html" title="Ruby-2.7.1">Prev</a>
          <p>
            Ruby-2.7.1
          </p>
        </li>
        <li class="next">
          <a accesskey="n" href="scons.html" title="SCons-3.1.2">Next</a>
          <p>
            SCons-3.1.2
          </p>
        </li>
        <li class="up">
          <a accesskey="u" href="prog.html" title=
          "Chapter&nbsp;13.&nbsp;Programming">Up</a>
        </li>
        <li class="home">
          <a accesskey="h" href="../index.html" title=
          "Beyond Linux� From Scratch     (System V Edition) - Version 2020-04-02">
          Home</a>
        </li>
      </ul>
    </div>
  </body>
</html>
